home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / net / spakparnet_0_5.lha / srv / nfslock.c < prev    next >
C/C++ Source or Header  |  1992-11-09  |  5KB  |  175 lines
  1. /********************************************************************
  2.  ** NETWORK FILE SYSTEM SERVICE
  3.  **
  4.  ** (c) Spak, Darrell Tam, c9107253@ee.newcastle.edu.au (1994)
  5.  ** phone (Australia) 049-829-710
  6.  **                    49-829-710
  7.  ** (c) SST Jan-Feb-Mar 1994
  8.  **
  9.  ** "LOCK" (locate_object) file support
  10.  **
  11.  ** TABS to 4
  12.  ********************************************************************/
  13.  
  14. #include "/snd/everything.h"
  15. #include <st/st_proto.h>
  16.  
  17. #include "nfsinternal.h"
  18. #include "nfsglobs_protos.h"
  19. #include "misc_protos.h"
  20.  
  21. #define LOCKMSG_SIZE (sizeof(struct LockDosMsg))
  22. struct LockDosMsg {
  23.     struct DosMsg        dm;
  24.     struct NFSLockReturn lockret;
  25.     struct InternalLock    *il;
  26.     struct PktMsgRecv    *pmr;
  27. };
  28.  
  29.  
  30.  
  31.  
  32.  
  33.  
  34.  
  35. /********************************************************************/
  36.     static void free_retret_lock(struct PktMsgRecv *pmr)
  37. /********************************************************************/
  38. {
  39. struct LockDosMsg *ldm = (void *)pmr->user.user2;
  40.  
  41. #ifdef DEBUG
  42.     fpf(out, "nfs_lock: Freeing memory\n");
  43. #endif
  44.  
  45.     if(!ldm->lockret.remote_il) {                    /* see if we had an error */
  46.     struct InternalLock *il = ldm->il;
  47.         REMOVE_FROM_LIST(il, il_first);                /* no lock? free the internal */
  48.         FreeMem(il, IL_SIZE);
  49.     }
  50.     FreeMem(ldm, LOCKMSG_SIZE);
  51.     FREE_PKTMSGRECV(pmr);                            /*     everything the server sent */
  52. }
  53.  
  54.  
  55.  
  56.  
  57.  
  58. /********************************************************************/
  59.     static void handle_lock_dos(struct LockDosMsg *ldm)
  60. /********************************************************************/
  61. {
  62. struct PktMsgRecv *pmr = ldm->pmr;
  63. struct InternalLock *il = ldm->il;
  64.  
  65. #ifdef DEBUG
  66.     fpf(out, "nfs_lock: result going home\n");
  67. #endif
  68.  
  69.     ldm->lockret.remote_res2 = ldm->dm.sp.sp_Pkt.dp_Res2;
  70.     if(il->reallock = BTOC(ldm->dm.sp.sp_Pkt.dp_Res1))
  71.         ldm->lockret.remote_il = RES_INTERNALLOCK(il);        /* ok! */
  72.     else
  73.         ldm->lockret.remote_il = 0;                            /* error */
  74.  
  75. /** SEND BACK THE RETURN CODES */
  76.     PUT_STDMSG(&pmr->pm.smsg, pmr->dmaport, TYPE_INTERNAL_SEND);
  77. }
  78.  
  79.  
  80.  
  81.  
  82.  
  83.  
  84.  
  85. /********************************************************************/
  86.     void *srv_lock(struct PktMsgRecv *pmr)
  87. /********************************************************************/
  88. {
  89. struct NFSLock        *req = (void *)pmr->req_body;
  90. struct LockDosMsg    *ldm;                    /* temp lock msg */
  91. struct InternalLock    *il;                    /* keep the lock */
  92. char    *fname = pmr->pm.send_body;            /* first byte should be length - BCPL */
  93. struct    MsgPort *handlerport;
  94.  
  95.     if(!(il = AllocMem(IL_SIZE, MEMF_PUBLIC | MEMF_CLEAR)))
  96.             return(&nfs_res_nomem);
  97.     if(!(ldm = AllocMem(LOCKMSG_SIZE, MEMF_PUBLIC)))
  98.         { FreeMem(il, IL_SIZE); return(&nfs_res_nomem); }
  99.  
  100. #ifdef DEBUG
  101.     fpf(out, "nfs_lock: name=%s, lock=%lx, maj=%ld, mode=%ld\n",
  102.         &fname[1], req->internallock, req->remote_majic, req->mode);
  103. #endif
  104.  
  105.     ADD_HEAD(il, il_first);
  106.     ldm->il = il;
  107.     ldm->pmr = pmr;
  108.     il->majic = ldm->lockret.remote_majic = GET_MAJIC;
  109.     il->machine = pmr->pm.dest;
  110.     INTERNAL_PREP_PKTMSG_DMA(&pmr->pm,
  111.                             EMEM_RETURNMSG,
  112.                             SERV_RETURN,                    /* that's all folks */
  113.                             &ldm->lockret,                    /* and this is it */
  114.                             req->sr.return_len);
  115.     pmr->user.user1 = free_retret_lock;                        /* up above */
  116.     pmr->user.user2 = (long)ldm;
  117.  
  118.     INIT_DOS_MSG(&ldm->dm, dosport, handle_lock_dos);
  119.     ldm->dm.sp.sp_Pkt.dp_Type = ACTION_LOCATE_OBJECT;
  120.     ldm->dm.sp.sp_Pkt.dp_Arg2 = CTOB(fname);
  121.     ldm->dm.sp.sp_Pkt.dp_Arg3 = req->mode;
  122.     handlerport =
  123.         FindHandlerPort(&fname[1],                            /* file name */
  124.                 req->internallock,    req->remote_majic,        /* input lock index */
  125.                 &ldm->dm.sp.sp_Pkt.dp_Arg1);                /* output lock offset */
  126.  
  127. #ifdef DEBUG
  128.     fpf(out, "nfs_lock: Asking handler (name=%s, msgport=%lx)\n", &fname[1], handlerport);
  129. #endif
  130.  
  131. /** DOS MSG TO THE HANDLER */
  132.     if(handlerport)
  133.         PutMsg(handlerport, ldm);
  134.  
  135. /** ERROR */
  136.     else {
  137.         ldm->lockret.remote_il = 0;
  138.         ldm->lockret.remote_res2 = ERROR_OBJECT_NOT_FOUND;
  139.         PUT_STDMSG(&pmr->pm.smsg, pmr->dmaport, TYPE_INTERNAL_SEND);
  140.     }
  141.     return(NULL);
  142. }
  143.  
  144.  
  145.  
  146.  
  147.  
  148. /********************************************************************/
  149.     void *srv_copylock(struct PktMsgRecv *pmr)
  150. /********************************************************************/
  151. {
  152. struct    NFSLock            *req = (void *)pmr->req_body;
  153. struct    LockDosMsg        *ldm;
  154. struct    InternalLock    *il, *orig_il =
  155.             GET_INTERNALLOCK(req->internallock, req->remote_majic);
  156.  
  157.     if(!orig_il) return(&nfs_res_notfound);
  158.     ACT_ALLOCMSG_THINGY(ldm, LOCKMSG_SIZE);            /* get dosmsgpkt+return memory */
  159.  
  160.     if(!(il = AllocMem(IL_SIZE, MEMF_PUBLIC | MEMF_CLEAR)))        /* internal lock */
  161.         { FreeMem(ldm, LOCKMSG_SIZE); return(&nfs_res_nomem); }
  162.     ADD_HEAD(il, il_first);
  163.     il->majic = ldm->lockret.remote_majic = GET_MAJIC;
  164.     il->machine = pmr->pm.dest;
  165.     ldm->il = il;
  166.     ldm->pmr = pmr;
  167.  
  168.     ACT_INIT_RETURN_PMR(pmr, free_retret_lock, ldm, &ldm->lockret, req);
  169.     INIT_DOS_MSG(&ldm->dm, dosport, handle_lock_dos);
  170.     ldm->dm.sp.sp_Pkt.dp_Type = ACTION_COPY_DIR;
  171.     ldm->dm.sp.sp_Pkt.dp_Arg1 = CTOB(orig_il->reallock);
  172.     PutMsg(orig_il->reallock->fl_Task, ldm);
  173.     return(NULL);
  174. }
  175.